package com.gadgets.framework.common.util;

import com.gadgets.framework.common.constant.GadgetsConstant;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashMap;

/**
 * @author UncleXiu
 * @version V1.0.0
 * @data 2020-09-17
 *
 */
@Component
@Deprecated
public class CacheUtils {

    private static final Logger logger = LoggerFactory.getLogger(CacheUtils.class);

    @Autowired
    private CacheManager cacheManager;

    static CacheUtils cacheUtils;

    @Autowired
    private RedisUtil redisUtil;

    private static final String SYS_CACHE = "sysCache";

    @PostConstruct
    public final void create(){
        cacheUtils = this;
    }

    public static CacheUtils getCacheUtilsInstance(){
        return cacheUtils;
    }

    /**
     * 将指定对象按照 Key 放入指定缓存
     * @param cacheName 缓存分区名
     * @param key       缓存键
     * @param value     缓存值
     * @return          操作结果
     */
    public boolean putAimCache(String cacheName, Object key, Object value){
        Cache cache = cacheManager.getCache(cacheName);
        if(null==cache){
            logger.error("缓存分区{}不存在",cacheName);
            return false;
        }
        cache.put(key, value);
        return true;
    }

    /**
     * 从指定缓存中获取指定类型的对象
     * @param cacheName 缓存分区名
     * @param key       缓存键
     * @param type      缓存值类型
     * @param <T>       泛型类型
     * @return          缓存值
     */
    public <T> T getAimCache(String cacheName, Object key, Class<T> type){
        Cache cache = cacheManager.getCache(cacheName);
        if(null==cache){
            logger.error("缓存分区{}不存在",cacheName);
            return null;
        }
        return cache.get(key, type);
    }

    /**
     * 将数据加入默认缓存区
     * @param key       缓存键
     * @param value     缓存值
     * @return          操作结果
     */
    public boolean putDefualtCache(Object key, Object value){
        return putAimCache(GadgetsConstant.CACHE_BLOCK.DEFAULT,key,value);
    }

    /**
     * 从默认缓存区中获取数据
     * @param key       缓存键
     * @param type      缓存值类型
     * @param <T>       泛型类型
     * @return          缓存值
     */
    public <T> T getDefaultCache(Object key, Class<T> type){
        return getAimCache(GadgetsConstant.CACHE_BLOCK.DEFAULT, key, type);
    }

    /**
     * 从指定缓存中清理指定Key
     * @param cacheName 缓存名
     * @param key       缓存键
     */
    public void evictAimCache(String cacheName, Object key){
        Cache cache = cacheManager.getCache(cacheName);
        if(null==cache){
            logger.error("缓存分区{}不存在",cacheName);
            return;
        }
        if(!cache.evictIfPresent(key)){
            logger.warn("缓存分区下{}没有键{}",cache,key);
        }
    }

    @SuppressWarnings("unchecked")
    public HashMap<String,Object> getUserSessionCache(Object key){
        return getAimCache(GadgetsConstant.CACHE_BLOCK.SESSION_CACHE,key,HashMap.class);
    }

    /**
     * 将系统参数加入缓存
     * @param key       参数名
     * @param value     参数值
     */
    public void putSysParamCache(String key, Object value){
        redisUtil.setCacheForSysParam(key, value);
    }

    /**
     * 从缓存中获取系统参数
     * @param key       参数名
     * @return          参数值
     */
    public String getSysParamCache(String key){
        HashMap<String ,Object> sysParamMap = redisUtil.getCacheMapForSysParam();
        return String.valueOf(sysParamMap.get(key));
    }

    /**
     * 将字典加入到缓存
     * @param groupCode     字典组编号
     * @param dictHashMap   字典列表
     */
    public void putDictParamCache(String groupCode, HashMap<String,String> dictHashMap){
        putAimCache(SYS_CACHE, groupCode, dictHashMap);
    }

    /**
     * 从缓存中获取字典组
     * @param groupCode 字典组编号
     * @return          字典列表
     */
    @SuppressWarnings("rawtypes")
    public HashMap getDictParamCache(String groupCode){
        return getAimCache(SYS_CACHE,groupCode,HashMap.class);
    }

}
